﻿using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;
using Ext.Net;
using ENT.GP.Core.Core;
using ENT.GP.Core.Rol;
using entgpguayas.Code;
using ENT.GP.Core.Mail;
using ENT.GP.Core;
using System.Xml;
using System.Text.RegularExpressions;
using System.Security.Permissions;
using System.IO;

namespace entgpguayas.Empresa
{
    public partial class wucEmpresa : ControlesUsuario
    {

        private static int _MaxUserImageSize    = Convert.ToInt32(ConfigurationManager.AppSettings.Get("LogoMaxSize"));
        private static int _MaxUserImageWidth   = Convert.ToInt32(ConfigurationManager.AppSettings.Get("LogoMaxWidth"));
        private static int _MaxUserImageHeight  = Convert.ToInt32(ConfigurationManager.AppSettings.Get("LogoMaxHeight"));
        private static string _ImageTypeInvalid = ManejadorRecursos.GetRecurso("MsgImageTypeInvalid");
        private  string _ImageSizeInvalid       = ManejadorRecursos.GetRecurso("MsgImageSizeInvalid");
        private  string _ImageInvalidDimensions = ManejadorRecursos.GetRecurso("MsgImageInvalidDimensions");

        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
               
            }
        }
        /// <summary>
        /// Por defecto '0'= Cerrar ventana '1'=Cerrar tab activo 
        /// </summary>
        /// <param name="type"></param>
        internal void SetTypeClose(string sType)
        {
            hidTypeClose.SetValue(sType);
          
        }
        /// <summary>
        /// Invoca metodo para actualizar datos de la grid
        /// </summary>
        private static void CallRefreshGridParent()
        {
            X.Js.AddScript("#{StoreEmpresa}.load();");
        }

        internal void Mostrar(string operacion,int id, Boolean ifUpdateGrid)
        {

            ImgLoad.Dispose();
            hidOperacion.SetValue(operacion);
            hidId.SetValue(id);
            hidIfUpdateGrid.SetValue(ifUpdateGrid);
            ImgLoad.ImageUrl = "../resources/images/logoNull.png";
            if (operacion=="Editar")
            {
                   Empresas objEmp = Empresas.Get(id);
                   txtNombre.SetValue(objEmp.Nombre);
                   txtDescripcion.SetValue(objEmp.Descripcion);
                   fufArchivosPP.SetValue(objEmp.UrlLogo);

                   ImgLoad.ImageUrl = string.Format("{0}{1}/{2}", new UtilRA().RutaArchivosEmpresaGlobal, objEmp.Codigo, objEmp.UrlLogo);
        
           }
           this.tabOpciones.Activate("0");
           winMiCuenta.Show();
        }
       
        protected void btnGuardar_Click(object sender, DirectEventArgs e)
        {
            try
            {
                string siglas     = "";
                string sOperacion = e.ExtraParams["hidOperacion_prm"].ToString();
                Empresas objEmp   = null;
                int id            = 0;
                int.TryParse(e.ExtraParams["hidId_prm"], out id);//int.TryParse(hidId.Text, out id);
                DeleteFilesTmp("tmp");
                
                if (sOperacion == "Editar")
                {
                    objEmp = Empresas.Get(id);
                    siglas = objEmp.Codigo;
                    //Borrar img con extensiones y nombres varios
                    DeleteFilesTmp(siglas);
                }
                else if (sOperacion == "Nuevo")
                {
                    objEmp = Empresas.New();
                    objEmp.Estado = 1;
                    objEmp.Nombre = e.ExtraParams["txtNombre_prm"];//txtNombre.Text;
                    siglas = CreateDirectory(ref objEmp);
                  
                }
                string sNombre = fufArchivosPP.FileName;
                if (sNombre!="")
                {
                  
                    sNombre = PostSaveFileImagen(siglas);
                    objEmp.UrlLogo = sNombre;
                }
                objEmp.Nombre = e.ExtraParams["txtNombre_prm"];//txtNombre.Text;
                objEmp.Descripcion = e.ExtraParams["txtDescripcion_prm"];//txtDescripcion.Text;
                
                objEmp = objEmp.Save();

                if (hidIfUpdateGrid.Text == "true")
                {
                    //Invocar methodo de ventana padre
                    CallRefreshGridParent();
                }
                if (hidOperacion.Text == "Editar")
                    UtilP.MostrarNotificacion("La empresa se actualizo correctamente", "Registro de Empresas", MessageBox.Icon.INFO);
                else
                    UtilP.MostrarNotificacion("La empresa se guardo correctamente", "Registro de Empresas", MessageBox.Icon.INFO);
                //Cerrar ventana y comprobar si es una empresa asignada cerrar tab
                X.Js.Call("winEmpresa.CloseTab"); 
           
            }
            catch (Exception ex)
            {
                Util.RegistarLog(ex.Message);
            }
        }
        /// <summary>
        /// Guardar la imagen en un path determinado 
        /// </summary>
        /// <param name="siglas"></param>
        /// <returns></returns>
        private string PostSaveFileImagen(string siglas)
        {
            string sNombre = fufArchivosPP.FileName;
            string sExtension = fufArchivosPP.PostedFile.FileName.Substring(fufArchivosPP.PostedFile.FileName.LastIndexOf('.') + 1);
            Random NumrandomExten = new Random(25);
            string numExt = NumrandomExten.Next().ToString();
            if (siglas == "tmp")
            {
                siglas = Session.SessionID + "_" + siglas;
                sNombre = string.Format("{0}{1}/{2}{3}.{4}", new UtilRA().RutaArchivosEmpresaGlobal,"tmp", siglas, numExt, sExtension);
              
            }
            else
            {
                sNombre = string.Format("{0}{1}/{2}{3}.{4}", new UtilRA().RutaArchivosEmpresaGlobal, siglas, siglas, numExt, sExtension);

            }

            fufArchivosPP.PostedFile.SaveAs(MapPath(sNombre));
            sNombre = siglas + numExt + "." + sExtension;
            return sNombre;
        }
        /// <summary>
        /// Eliminar archivos de un directorio dado
        /// </summary>
        /// <param name="siglas"></param>
        private void DeleteFilesTmp(string siglas)
        {
            string imgDelete  = "";
            string fileDelete = "";
            if (siglas == "tmp")
            {
                imgDelete = string.Format("{0}{1}/", new UtilRA().RutaArchivosEmpresaGlobal, siglas);
                fileDelete = Session.SessionID + "_" + siglas;
            }
            else
            {
                imgDelete = string.Format("{0}{1}/", new UtilRA().RutaArchivosEmpresaGlobal, siglas);
                fileDelete = siglas;
            }
            foreach (string archivo in Directory.GetFiles(MapPath(imgDelete), fileDelete + "*.*"))
            {
                File.Delete(archivo);
            }
        }
        protected void txtNombre_Change(object sender, DirectEventArgs e)
        {
            try
            {
                if (Empresas.VerificarNombre(e.ExtraParams["txtNombre_prm_t"]))//txtNombre.Text
                {
                       UtilP.MostrarNotificacion("La empresa ya existe", "Registro Empresa", MessageBox.Icon.WARNING);
                       txtNombre.Text = "";
                }
            
            }
            catch (Exception ex)
            {
                Util.RegistarLog(ex.Message);
            }
        }
        /// <summary>
        /// Creacion de directorios por empresa
        /// </summary>
        /// <param name="objEmp"></param>
        /// <returns></returns>
        private string CreateDirectory(ref Empresas objEmp)
        {

            string siglas = objEmp.Nombre.Substring(0, 3);
            siglas = siglas.ToLower();
            string siglasTest = "";
            while (siglasTest == "")
            {
                Random r = new Random(50);

                if (!Empresas.VerificarCodigo(siglas))
                {
                    siglasTest = siglas;
                }
                else
                {
                    siglas = siglas.Substring(0, 2) + r.Next().ToString();
                    siglas = siglas.Substring(0, 3);
                }
            }
            objEmp.Codigo = siglas;
            // Specify a "currently active folder"
            string newPath = string.Format("{0}{1}/", new UtilRA().RutaArchivosEmpresaGlobal, objEmp.Codigo);
            string activeDir = HttpContext.Current.Server.MapPath(newPath);
            string sPathTmp = "";
            string[] namesDir = new string[] { "load", "Temp", "images" };
            if (!System.IO.File.Exists(activeDir))
            {
                // Create the subfolder
                System.IO.Directory.CreateDirectory(activeDir);
                sPathTmp = string.Format("{0}/{1}", newPath, "resources");
                activeDir = HttpContext.Current.Server.MapPath(sPathTmp);
                newPath = sPathTmp;
                // Create the subfolder
                System.IO.Directory.CreateDirectory(activeDir);
                //Crear subcarpetas
                for (int x = 0; x < namesDir.Length; x++)
                {
                    sPathTmp = string.Format("{0}/{1}", newPath, namesDir[x]);
                    activeDir = HttpContext.Current.Server.MapPath(sPathTmp);
                    // Create the subfolder
                    System.IO.Directory.CreateDirectory(activeDir);
                }
            }
            return siglas;
        }


      
        /// <summary>
        /// Subir un archivo al proyecto
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void SubirArchivo_Click(object sender, DirectEventArgs e)
        {
            SetError("");

            if (IsImageValid(this.fufArchivosPP.PostedFile))
            {
                string tpl = "Subido el archivo Correctamente: {0}<br/>Size: {1} bytes";
                try
                {

                    string path = PostSaveFileImagen("tmp");
                    if (this.fufArchivosPP.HasFile)
                    {
                        X.Msg.Show(new MessageBoxConfig
                        {
                            Buttons = MessageBox.Button.OK,
                            Icon = MessageBox.Icon.INFO,
                            Title = "Éxito",
                            Message = string.Format(tpl, this.fufArchivosPP.PostedFile.FileName, this.fufArchivosPP.PostedFile.ContentLength)
                        });
                        ImgLoad.ImageUrl = "../resources/empresas/tmp/" + path;
                       
                    }
                    else
                    {
                        ShowMsgErrorFileImg();
                    }
                }
                catch (Exception ex)
                {
                    Util.RegistarLog(ex.Message);
                    ShowMsgErrorFileImg();
                }
            }
            else
            {
                ShowMsgErrorFileImg();
            }
        }
        /// <summary>
        /// Mostrar mensaje de error 
        /// </summary>
        private void ShowMsgErrorFileImg()
        {
            this.fufArchivosPP.SetValue("");
            this.fufArchivosPP.Clear();

            X.Msg.Show(new MessageBoxConfig
            {
                Buttons = MessageBox.Button.OK,
                Icon = MessageBox.Icon.ERROR,
                Title = "Fallo",
                Message = "Archivo no fue subido!!!"
            });
        }
        #region Imagenes
        /// <summary>
        /// Validar imagenes
        /// </summary>
        /// <param name="objFile"></param>
        /// <returns></returns>
        private bool IsImageValid(HttpPostedFile objFile)
        {
            ValidateFiles validateImage = new ValidateFiles();
            validateImage.SetUserImageSize(_MaxUserImageWidth, _MaxUserImageHeight);

            if (!Get_IsImageValid(objFile, validateImage))
                return SetError(_ImageTypeInvalid);
            if (!Get_IsImageDimensionsValid(objFile, validateImage))
                return SetError(_ImageInvalidDimensions);
            if (!Get_IsImageSizeValid(objFile, validateImage))
                return SetError(_ImageSizeInvalid);
            return true;
        }

        private bool SetError(string msg)
        {
            if (!lblWarnings.Visible)
                lblWarnings.Visible = true;

            lblWarnings.Text = msg;
            return false;
        }

        private bool Get_IsImageValid(HttpPostedFile objFile, ValidateFiles validateImage)
        {
            return validateImage.ValidateFileIsImage(objFile.ContentType);
        }

        private bool Get_IsImageDimensionsValid(HttpPostedFile objFile, ValidateFiles validateImage)
        {
            return validateImage.ValidateUserImageDimensions(objFile);
        }

        private bool Get_IsImageSizeValid(HttpPostedFile objFile, ValidateFiles validateImage)
        {
            return validateImage.ValidateUserImageSize(_MaxUserImageSize, objFile.ContentLength);
        }
        #endregion 
      
     
    }
}
